package com.jifeng.api.crud.service.impl;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jifeng.api.constant.HttpStatusEnum;
import com.jifeng.api.crud.constant.FieldConstant;
import com.jifeng.api.crud.dao.TerminalDao;
import com.jifeng.api.crud.entity.FeeConfigEntity;
import com.jifeng.api.crud.entity.OrderEntity;
import com.jifeng.api.crud.entity.TerminalEntity;
import com.jifeng.api.crud.service.FeeConfigService;
import com.jifeng.api.crud.service.OrderService;
import com.jifeng.api.crud.service.TerminalService;
import com.jifeng.api.crud.utils.CheckParamsRs;
import com.jifeng.api.crud.utils.UpdateStatusRs;
import com.jifeng.api.utils.*;
import com.jifeng.api.vo.ReqRentVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.yaml.snakeyaml.events.Event;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;


@Service("terminalService")
@Slf4j
public class TerminalServiceImpl extends ServiceImpl<TerminalDao, TerminalEntity> implements TerminalService {

    @Autowired
    OrderService orderService;

    @Autowired
    TerminalService terminalService;

    @Autowired
    CheckParamsRs checkParamsRs;

    @Autowired
    UpdateStatusRs updateStatusRs;

    @Autowired
    FeeConfigService feeConfigService;


    @Override
    public R updateTerminalStatus(Map<String, Object> params) {
//        log.info("path：{}，errMsg：{}", getRequestUrl(), "设置机柜状态为空闲");
        try {
            if (params.get("terminalId") == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号可能为空或机柜不存在");
                return R.error(404, "机柜编号格式错误");
            }

            String terminalId = params.get("terminalId").toString();

            /**
             * 校验 机柜编号
             */
            boolean checkIot = checkParamsRs.checkIot(terminalId);
            if (!checkIot) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号格式错误");
                return R.error(404, "机柜编号格式错误");
            }

            /**
             * 校验机柜表中是否有该机柜
             */
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
            if (terminalEntity == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜无效");
                return R.error(405, "非法的机柜编号");
            }

            terminalEntity.setRentState(0);
            boolean update = this.updateById(terminalEntity);
            if (update) {
                return R.ok();
            }
            return R.error();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }

    }

    @Override
    public R isRent(Map<String, Object> params) {
        String terminalId = "";
        String mobile = "";
        try {
            terminalId = params.get("terminalId").toString();
            mobile = params.get("mobile").toString();

            /**
             * 校验 机柜编号 和 手机号格式
             */
            boolean checkIotAndMobileRs = checkParamsRs.checkIotAndMobile(terminalId, mobile);
            if (!checkIotAndMobileRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号或手机号格式错误");
                return R.error(404, "机柜编号或手机号格式错误");
            }

            /**
             * 校验机柜表中是否有该机柜
             */
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId), false);
            if (terminalEntity == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜无效");
                return R.error(405, "非法的机柜编号");
            }

            /**
             * 查看该用户是否存在正在租赁的订单
             */
            List<OrderEntity> entities = orderService.list(new QueryWrapper<OrderEntity>().eq(FieldConstant.T_ORDER_MOBILE, mobile).eq(FieldConstant.T_ORDER_STATUS, 4));
            if (!entities.isEmpty()) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "有在租用的设备，请先归还");
                return R.error(402, "有在租用的设备，请先归还").put("data", entities.get(entities.size() - 1));
            }

            /**
             * 查看该用户是否存在未结算的订单
             */
            List<OrderEntity> entities2 = orderService.list(new QueryWrapper<OrderEntity>().eq(FieldConstant.T_ORDER_MOBILE, mobile).eq(FieldConstant.T_ORDER_STATUS, 6));
            if (!entities2.isEmpty()) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "有未结算的订单，请先结算");
                return R.error(403, "有未结算的订单，请先结算").put("data", entities2.get(entities2.size() - 1));
            }

            /**
             * 校验该机柜是否空闲
             */
            // TODO: 2020/9/26 查询更新失败表
            Integer rentState = terminalEntity.getRentState();
            if (rentState == 1) {
                List<OrderEntity> orderEntities = orderService.list(new QueryWrapper<OrderEntity>().eq(FieldConstant.T_ORDER_TERMINAL_ID, terminalId));
                if (!orderEntities.isEmpty()) {
                    OrderEntity orderEntity = orderEntities.get(orderEntities.size() - 1);

                    /**
                     * 如果不是同一手机用户
                     */
                    if (!orderEntity.getMobile().equals(mobile)) {

                        /**
                         * 判断操作时间是否小于3分钟
                         */
                        Date updateTime = orderEntity.getUpdateTime();
                        Date date = new Date();
                        long between = DateUtil.between(updateTime, date, DateUnit.SECOND);
                        if (between < 180) {
                            log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜正在被租用");
                            return R.error(401, "机柜正在被租用,如有问题请联系管理员");
                        }
                    }
                }
            }

            /**
             * 如果是空闲状态则设置机柜为繁忙
             */
            terminalEntity.setRentState(1);
            boolean updateTerminalRs = this.updateById(terminalEntity);
            if (!updateTerminalRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                return R.error("租赁该机柜失败，请重试");
            }

            /**
             * 查询费用配置信息
             */
            List<FeeConfigEntity> feeConfigEntities = feeConfigService.list();
            FeeConfigEntity feeConfigEntity;
            if (feeConfigEntities.isEmpty()) {
                feeConfigEntity = new FeeConfigEntity();
                feeConfigEntity.setBaseFee(500);
            } else {
                feeConfigEntity = feeConfigEntities.get(feeConfigEntities.size() - 1);
            }

            /**
             * 创建订单
             */
            OrderEntity saveOrder = new OrderEntity();
            saveOrder.setTerminalId(terminalId);
            saveOrder.setMobile(mobile);
            saveOrder.setState(1);
            saveOrder.setComState(0);
            saveOrder.setFee(feeConfigEntity.getBaseFee());
            boolean save = orderService.save(saveOrder);
            if (!save) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "创建订单失败");
                terminalEntity.setRentState(0);
                boolean update = this.updateById(terminalEntity);
                if (!update) {
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                    // TODO: 2020/9/26 往更新失败表插入记录
                }
                return R.error("创建订单失败");
            }

            /**
             * 调用下位机租赁设备
             */
            boolean rentDeviceRs = HttpUtils.rentDevice(terminalId, "1", mobile, saveOrder.getId().toString());
            if (!rentDeviceRs) {
                terminalEntity.setRentState(0);
                boolean update = this.updateById(terminalEntity);
                if (!update) {
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                    // TODO: 2020/9/26 往更新失败表插入记录
                }
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "设备未连接");
                return R.error("设备未连接");
            }
            Map<String, Object> rsMap = new HashMap<>();
            rsMap.put("number", saveOrder.getId());
            return R.ok().put("data", rsMap);
        } catch (Exception e) {
            e.printStackTrace();
            TerminalEntity terminalEntity = new TerminalEntity();
            terminalEntity.setRentState(0);
            boolean update = this.update(terminalEntity, new UpdateWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
            if (!update) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                // TODO: 2020/9/26 往更新失败表插入记录
            }
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R updateIsRentResult(ReqRentVo params) {
        String terminalId = "";
        try {
            terminalId = params.getTerminalId();
            String mobile = params.getMobile();
            String rentCode = params.getRentCode();
            String deviceId = params.getDeviceId();
            // 订单id
            String orderId = params.getNumber();

            /**
             * 校验 机柜编号 和 手机号格式
             */
            boolean checkIotAndMobileRs = checkParamsRs.checkIotAndMobile(terminalId, mobile);
            if (!checkIotAndMobileRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号或手机号格式错误");
                return R.error("Incorrect terminal_id or phone format");
            }
            if (rentCode.equals("") || deviceId.equals("")) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "租赁状态码和设备编号无效");
                return R.error("Invalid code and device_id");
            }

            /**
             * 查询订单
             */
            OrderEntity orderEntity = orderService.getById(orderId);
            if (orderEntity == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "未创建订单");
                return R.error("Invalid order");
            }

            /**
             * rentCode：0 无法租赁
             * 设置订单状态为：查询发送
             */
            if (rentCode.equals("0")) {
                orderEntity.setComState(1);
                orderEntity.setRevTime(new Date());
                boolean updateOrderRs = orderService.updateById(orderEntity);
                if (!updateOrderRs) {
                    // TODO: 2020/9/26 往更新失败表中插入一条记录
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新订单失败");
                    return R.error("Fail update order");
                }

                /**
                 * 设置机柜为空闲
                 */
                TerminalEntity terminalEntity = new TerminalEntity();
                terminalEntity.setRentState(0);
                boolean updateTerminalRs = terminalService.update(terminalEntity, new UpdateWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
                if (!updateTerminalRs) {
                    // TODO: 2020/9/26 往更新失败表中插入一条记录
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜失败");
                }
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "设备繁忙，无法租赁");
                return R.error("Device is busy");
            }

            /**
             * rentCode：2 可租赁设备
             * 设置订单状态为：查询有可用
             */
            if (rentCode.equals("2")) {
                orderEntity.setState(2);
                orderEntity.setDeviceId(deviceId);
                orderEntity.setComState(2);
                orderEntity.setRevTime(new Date());
                boolean updateOrderRs = orderService.updateById(orderEntity);
                if (!updateOrderRs) {
                    // TODO: 2020/9/26 往更新失败表中插入一条记录
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新订单失败");
                    return R.error("Fail update order");
                }

                /**
                 * 将订单状态设为 支付调用中
                 */
                orderEntity.setComState(3);
                orderEntity.setRevTime(new Date());
                boolean updateOrderRs2 = orderService.updateById(orderEntity);
                if (!updateOrderRs2) {
                    // TODO: 2020/9/26 往更新失败表中插入一条记录
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新订单失败");
                    return R.error("Fail update order");
                }
                return R.ok();
            }
            return R.error("Invalid code");
        } catch (Exception e) {
            /**
             * 设置机柜为空闲
             */
            TerminalEntity terminalEntity = new TerminalEntity();
            terminalEntity.setRentState(0);
            boolean update = terminalService.update(terminalEntity, new UpdateWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
            if (!update) {
                // TODO: 2020/9/26 往更新失败表中插入一条记录
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜失败");
            }
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.error(500, "System is busy");
        }
    }

    @Override
    public R updateRentResult(ReqRentVo params) {
        return R.ok();
//        String terminalId = "";
//        try {
//            terminalId = params.getTerminalId();
//            String mobile = params.getMobile();
//            String rentCode = params.getRentCode();
//            String deviceId = params.getDeviceId();
//            // 订单id
//            String orderId = params.getNumber();
//
//            /**
//             * 校验 机柜编号 和 手机号格式
//             */
//            boolean checkIotAndMobileRs = checkParamsRs.checkIotAndMobile(terminalId, mobile);
//            if (!checkIotAndMobileRs) {
//                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号或手机号格式错误");
//                return R.error("Incorrect terminal_id or phone format");
//            }
//            if (rentCode.equals("") || deviceId.equals("")) {
//                log.warn("path：{}，errMsg：{}", getRequestUrl(), "某些参数为空");
//                return R.error("Invalid code and device_id");
//            }
//
//            /**
//             * 查询机柜信息
//             */
//            TerminalEntity terminalEntity = terminalService.getById(terminalId);
//            if (terminalEntity == null) {
//                log.warn("path：{}，errMsg：{}", getRequestUrl(), "不存在该机柜");
//                return R.error("Invalid terminal");
//            }
//
//            /**
//             * 查询订单信息
//             */
//            OrderEntity orderEntity = orderService.getById(orderId);
//            if (orderEntity == null) {
//                terminalEntity.setRentState(0);
//                boolean update = terminalService.updateById(terminalEntity);
//                if (!update) {
//                    // TODO: 2020/9/26  往更新失败表中插入记录
//                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
//                }
//                log.warn("path：{}，errMsg：{}", getRequestUrl(), "未创建订单");
//                return R.error("Fail update order");
//            }
//            /**
//             * rentCode：0 无法租赁
//             * 设置订单状态为：租赁失败
//             */
//            if (rentCode.equals("0")) {
//                orderEntity.setComState(8);
//                orderEntity.setRevTime(new Date());
//                boolean updateOrderRs = orderService.updateById(orderEntity);
//                if (!updateOrderRs) {
//                    terminalEntity.setRentState(0);
//                    boolean update = terminalService.updateById(terminalEntity);
//                    if (!update) {
//                        // TODO: 2020/9/26  往更新失败表中插入记录
//                        log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
//                    }
//                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新订单失败");
//                    return R.error("Fail update order");
//                }
//
//                /**
//                 * 将机柜状态设为空闲
//                 */
//                terminalEntity.setRentState(0);
//                boolean updateTerminalRs = terminalService.updateById(terminalEntity);
//                if (!updateTerminalRs) {
//                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜失败");
//                    return R.error("Fail update terminal");
//                }
//                log.warn("path：{}，errMsg：{}", getRequestUrl(), "问题咨询客服");
//                return R.error("Problem consulting customer service");
//            }
//            /**
//             * rentCode：4
//             * 设置订单状态为：租赁成功
//             */
//            if (rentCode.equals("4")) {
//                orderEntity.setState(4);
//                orderEntity.setDeviceId(deviceId);
//                orderEntity.setComState(7);
//                orderEntity.setRevTime(new Date());
//                orderEntity.setStartFeeTime(new Date());
//                boolean updateOrderRs = orderService.updateById(orderEntity);
//                if (!updateOrderRs) {
//                    terminalEntity.setRentState(0);
//                    boolean update = terminalService.updateById(terminalEntity);
//                    if (!update) {
//                        // TODO: 2020/9/26  往更新失败表中插入记录
//                        log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
//                    }
//                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新订单失败");
//                    return R.error("Fail update order");
//                }
//
//                /**
//                 * 将机柜状态设为空闲
//                 */
//                terminalEntity.setRentState(0);
//                boolean updateTerminalRs = terminalService.updateById(terminalEntity);
//                if (!updateTerminalRs) {
//                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜失败");
//                    return R.error("Fail update terminal");
//                }
//                return R.ok();
//            }
//            return R.error();
//        } catch (Exception e) {
//            TerminalEntity terminalEntity = new TerminalEntity();
//            terminalEntity.setIot(terminalId);
//            terminalEntity.setRentState(0);
//            boolean update = terminalService.updateById(terminalEntity);
//            if (!update) {
//                // TODO: 2020/9/26  往更新失败表中插入记录
//                log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
//            }
//            e.printStackTrace();
//            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
//            return R.error(500,"System is busy");
//        }
    }

    @Override
    public R waitPay(ReqRentVo params) {
        String terminalId = "";
        try {
            terminalId = params.getTerminalId();
            String mobile = params.getMobile();
            /**
             * 校验 机柜编号 和 手机号格式
             */
            boolean checkIotAndMobileRs = checkParamsRs.checkIotAndMobile(terminalId, mobile);
            if (!checkIotAndMobileRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号或手机号格式错误");
                return R.error("机柜编号或手机号格式错误");
            }

            /**
             * 查询机柜信息
             */
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
            if (terminalEntity == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜无效");
                return R.error("机柜无效");
            }

            /**
             * 校验 该用户该机柜是否已经创建订单
             */
            List<OrderEntity> orderEntities = orderService.list(new QueryWrapper<OrderEntity>().eq(FieldConstant.T_ORDER_TERMINAL_ID, terminalId).eq(FieldConstant.T_ORDER_MOBILE, mobile));
            if (orderEntities.isEmpty()) {
                terminalEntity.setRentState(0);
                boolean update = terminalService.updateById(terminalEntity);
                if (!update) {
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                    // TODO: 2020/9/26 往更新失败表插入记录
                }
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "订单不存在");
                return R.error("订单不存在");
            }

            OrderEntity orderEntity = orderEntities.get(orderEntities.size() - 1);
            Integer comState = orderEntity.getComState();
            if (comState == 3) {
                log.info("path：{}，errMsg：{}", getRequestUrl(), "准备支付中");
                return R.ok(200, "准备支付中");
            }
            if (comState == 0) {
                log.info("path：{}，errMsg：{}", getRequestUrl(), "设备查询中");
                return R.ok(201, "设备查询中");
            }
            if (comState == 1) {
                terminalEntity.setRentState(0);
                boolean update = terminalService.updateById(terminalEntity);
                if (!update) {
                    log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                    // TODO: 2020/9/26 往更新失败表插入记录
                }
                log.info("path：{}，errMsg：{}", getRequestUrl(), "无可用设备");
                return R.ok(202, "无可用设备");
            }
            return R.error();
        } catch (Exception e) {
            TerminalEntity terminalEntity = new TerminalEntity();
            terminalEntity.setRentState(0);
            boolean update = terminalService.update(terminalEntity, new UpdateWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
            if (!update) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜状态失败");
                // TODO: 2020/9/26 往更新失败表插入记录
            }
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R isRentFinish(ReqRentVo params) {
        try {
            String terminalId = params.getTerminalId();
            String mobile = params.getMobile();

            /**
             * 校验 机柜编号 和 手机号格式
             */
            boolean isIot = RegexUtils.isIOT(terminalId);
            if (!isIot) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号格式错误");
                return R.error("机柜编号格式错误");
            }
            if (!RegexUtils.isPhone(mobile)) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "手机号无效");
                return R.error("机柜或手机号无效");
            }

            /**
             * 校验 该用户该机柜是否已经创建订单
             */
            List<OrderEntity> orderEntities = orderService.list(new QueryWrapper<OrderEntity>().eq(FieldConstant.T_ORDER_TERMINAL_ID, terminalId).eq(FieldConstant.T_ORDER_MOBILE, mobile));
            if (orderEntities.isEmpty()) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "订单不存在");
                return R.error("订单不存在");
            }
            OrderEntity orderEntity = orderEntities.get(orderEntities.size() - 1);
            Integer comState = orderEntity.getComState();
            if (comState == 7) {
                log.info("path：{}，errMsg：{}", getRequestUrl(), "租赁成功");
                return R.ok(200, "租赁成功");
            }
            if (comState == 3) {
                log.info("path：{}，errMsg：{}", getRequestUrl(), "设备弹出中");
                return R.ok(201, "支付处理中");
            }
            if (comState == 5) {
                log.info("path：{}，errMsg：{}", getRequestUrl(), "租赁失败");
                return R.ok(202, "支付失败");
            }
            return R.error();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R updateTerminalAll(TerminalEntity terminalEntity) {
        try {
            String terminalId = terminalEntity.getIot();

            /**
             * 校验 机柜编号
             */
            boolean checkIot = checkParamsRs.checkIot(terminalId);
            if (!checkIot) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号格式错误");
                return R.error(404, "机柜编号格式错误");
            }

            /**
             * 校验机柜表中是否有该机柜
             */
            TerminalEntity terminal = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId), false);
            if (terminal == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜不存在");
                return R.error(405, "机柜不存在");
            }

            boolean updateRs = this.update(terminalEntity, new UpdateWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalId));
            if (!updateRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "更新机柜数据失败");
                return R.error("更新机柜数据失败");
            }

            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R getLocationInfo(Map<String, Object> params) {
        try {
            String userId = params.get("userId").toString();
            Map<String, Object> userInfo = HttpUtils.getUserIdByToken(getRequest());
            if (userInfo == null) {
                log.warn("path：{}，errMsg：{}，cause：{}", getRequestUrl(), "获取token信息失败", "未知异常");
                return R.error("获取token信息失败");
            }
            String type = userInfo.get("type").toString();
            if (type.equals("2")) {
                String userIdByToken = userInfo.get("id").toString();
                if (!userId.equals(userIdByToken)) {
                    log.warn("path：{}，errMsg：{}，cause：{}", getRequestUrl(), "只能查询本人的机柜位置信息", "所传userId和token中的userId不一致");
                    return R.error("只能查询本人的机柜位置信息");
                }
            }
            List<TerminalEntity> terminalEntities = this.list(new QueryWrapper<TerminalEntity>().eq("user_id", userId));
            List<Map<String, Object>> collect = terminalEntities.stream().map(terminalEntity -> {
                Map<String, Object> map = new HashMap<>();
                map.put("id", terminalEntity.getId());
                map.put("IOT", terminalEntity.getIot());
                map.put("lng", terminalEntity.getLng());
                map.put("lat", terminalEntity.getLat());
                map.put("location", terminalEntity.getLocation());
                return map;
            }).collect(Collectors.toList());
            if (collect.isEmpty()) {
                return R.error().put("data", collect);
            }
            return R.ok().put("data", collect);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }

    }

    @Override
    public R insertTerminal(TerminalEntity terminal) {
        try {
            /**
             * 校验 机柜编号
             */
            boolean checkIotRs = checkParamsRs.checkIot(terminal.getIot());
            if (!checkIotRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号格式错误");
                return R.error(404, "机柜编号格式错误");
            }

            /**
             * 校验机柜是否存在
             */
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminal.getIot()));
            if (terminalEntity != null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), HttpStatusEnum.HTTP_TERMINAL_EXIT.getMsg());
                return R.error(HttpStatusEnum.HTTP_TERMINAL_EXIT.getCode(), HttpStatusEnum.HTTP_TERMINAL_EXIT.getMsg());
            }

            /**
             * 进行保存机柜操作
             */
            boolean save = this.save(terminal);
            if (!save) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), HttpStatusEnum.HTTP_TERMINAL_ADD.getMsg());
                return R.error(HttpStatusEnum.HTTP_TERMINAL_ADD.getCode(), HttpStatusEnum.HTTP_TERMINAL_ADD.getMsg());
            }

            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R deleteTerminal(Map<String, Object> params) {
        try {
            String iot = Convert.toStr(params.get("id"));

            /**
             * 校验 机柜编号
             */
            boolean checkIotRs = checkParamsRs.checkIot(iot);
            if (!checkIotRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号格式错误");
                return R.error(404, "机柜编号格式错误");
            }

            /**
             * 校验机柜是否存在
             */
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, iot));
            if (terminalEntity == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), HttpStatusEnum.HTTP_TERMINAL_NO_EXIT.getMsg());
                return R.error(HttpStatusEnum.HTTP_TERMINAL_NO_EXIT.getCode(), HttpStatusEnum.HTTP_TERMINAL_NO_EXIT.getMsg());
            }

            boolean remove = this.remove(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, iot));
            if (!remove) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), HttpStatusEnum.HTTP_TERMINAL_DELETE.getMsg());
                return R.error(HttpStatusEnum.HTTP_TERMINAL_DELETE.getCode(), HttpStatusEnum.HTTP_TERMINAL_DELETE.getMsg());
            }

            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R updateTerminal(TerminalEntity terminal) {
        try {
            /**
             * 校验 机柜编号
             */
            boolean checkIotRs = checkParamsRs.checkIot(terminal.getIot());
            if (!checkIotRs) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "机柜编号格式错误");
                return R.error(404, "机柜编号格式错误");
            }

            /**
             * 校验机柜是否存在
             */
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminal.getIot()));
            if (terminalEntity == null) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), HttpStatusEnum.HTTP_TERMINAL_NO_EXIT.getMsg());
                return R.error(HttpStatusEnum.HTTP_TERMINAL_NO_EXIT.getCode(), HttpStatusEnum.HTTP_TERMINAL_NO_EXIT.getMsg());
            }

            /**
             * 进行更新操作
             */
            boolean update = this.update(terminal, new UpdateWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, terminalEntity.getIot()));
            if (!update) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), HttpStatusEnum.HTTP_TERMINAL_UPDATE.getMsg());
                return R.error(HttpStatusEnum.HTTP_TERMINAL_UPDATE.getCode(), HttpStatusEnum.HTTP_TERMINAL_UPDATE.getMsg());
            }

            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R getOneTerminal(Map<String, Object> params) {
        try {
            String iot = params.get("id").toString();
            TerminalEntity terminalEntity = this.getOne(new QueryWrapper<TerminalEntity>().eq(FieldConstant.T_TERMINAL_IOT, iot));
            if (terminalEntity == null) {
                return R.error().put("data", terminalEntity);
            }
            return R.ok().put("data", terminalEntity);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R remoteOpen(Map<String, Object> params) {
        try {
            String terminalId = params.get("terminalId").toString();
            String num = params.get("num").toString();
            boolean control = HttpUtils.optCabitControl(terminalId, num);
            if (!control) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "远程控制开仓失败");
                return R.error("远程控制开仓失败");
            }
            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    @Override
    public R remoteDisable(Map<String, Object> params) {
        try {
            String terminalId = params.get("terminalId").toString();
            String num = params.get("num").toString();
            boolean control = HttpUtils.optCabitStauts(terminalId, num);
            if (!control) {
                log.warn("path：{}，errMsg：{}", getRequestUrl(), "远程禁用失败");
                return R.error("远程禁用失败");
            }
            return R.ok();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("path：{}，errMsg：{}", getRequestUrl(), e.getMessage());
            return R.sysError();
        }
    }

    public String getRequestUrl() {
        return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest().getRequestURI();
    }

    public HttpServletRequest getRequest() {
        return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
    }
}